// contentPage.js
Page({
  data: {
    currentTab: 0, // 当前选中的tab，默认为0（文字）
    dynamicContent: '', // 存储从API获取的内容
    originalContent: true, // 是否显示原始内容
    currentImage: '', // 存储当前显示的图片URL
    imageLoading: false, // 图片加载状态
    imageFullScreen: false, // 图片全屏状态
    currentVideo: '', // 存储当前显示的视频URL
    videoLoading: false // 视频加载状态
  },
  
  // 页面加载时初始化
  onLoad: function() {
    // 页面加载时的初始化操作
    // 初始化防抖动标志
    this.isImageSliding = false;
    this.isVideoSliding = false;
    // 初始化当前图片类型
    this.currentImageType = '随机女神';
    // 初始化视频全屏状态
    this.videoFullScreen = false;
  },
  
  // 页面显示时，如果当前是图片tab或视频tab，获取对应内容
  onShow: function() {
    if (this.data.currentTab === 1 && !this.data.currentImage) {
      this.getRandomImage('随机女神');
    } else if (this.data.currentTab === 2 && !this.data.currentVideo) {
      this.getRandomVideo();
    }
  },
  
  // 切换tab
  switchTab: function(e) {
    const tabIndex = parseInt(e.currentTarget.dataset.tab);
    this.setData({
      currentTab: tabIndex,
      originalContent: true, // 切换tab时重置为原始内容
      dynamicContent: ''
    });
    
    // 当切换到图片tab时，自动获取图片
    if (tabIndex === 1) {
      this.getRandomImage('随机女神');
    } 
    // 当切换到视频tab时，自动获取视频
    else if (tabIndex === 2) {
      this.getRandomVideo();
    }
  },
  
  // 获取随机图片的API调用函数
  getRandomImage: function(type) {
    // 重置重试计数
    this.imageRetryCount = 0;
    
    this.setData({
      imageLoading: true
    });
    
    wx.request({
      url: `https://s3u416zkby.ny.takin.cc/freeapilocal/img?type=${encodeURIComponent(type)}`,
      method: 'GET',
      success: (res) => {
        if (res.data.code === 200 && res.data.data && res.data.data.content) {
          // 提取并清理图片链接（去除可能的额外字符）
          let imageUrl = res.data.data.content.trim();
          
          // 处理各种可能的包装字符
          if (imageUrl.startsWith('`') && imageUrl.endsWith('`')) {
            imageUrl = imageUrl.substring(1, imageUrl.length - 1);
          } else if (imageUrl.startsWith('"') && imageUrl.endsWith('"')) {
            imageUrl = imageUrl.substring(1, imageUrl.length - 1);
          } else if (imageUrl.startsWith('\'') && imageUrl.endsWith('\'')) {
            imageUrl = imageUrl.substring(1, imageUrl.length - 1);
          }
          
          // 检查并转换协议：http -> https
          if (imageUrl.startsWith('http://')) {
            imageUrl = imageUrl.replace('http://', 'https://');
          }
          
          // 确保URL是完整的
          if (!imageUrl.startsWith('http://') && !imageUrl.startsWith('https://')) {
            imageUrl = 'https://' + imageUrl;
          }
          
          // 添加时间戳参数避免缓存
          if (imageUrl.includes('?')) {
            imageUrl = imageUrl + '&' + 'timestamp=' + Date.now();
          } else {
            imageUrl = imageUrl + '?' + 'timestamp=' + Date.now();
          }
          
          console.log('处理后的图片URL:', imageUrl);
          
          this.setData({
            currentImage: imageUrl
          });
        } else {
          wx.showToast({
            title: '获取图片失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('图片API调用失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        this.setData({
          imageLoading: false
        });
      }
    });
  },
  
  // 随机女神按钮点击事件
  randomGirl: function() {
    this.getRandomImage('随机女神');
  },
  
  // 随机动漫按钮点击事件
  randomAnime: function() {
    this.getRandomImage('随机动漫');
  },
  
  // 随机帅哥按钮点击事件
  randomBoy: function() {
    this.getRandomImage('随机帅哥');
  },
  
  // 随机风景按钮点击事件
  randomScenery: function() {
    this.getRandomImage('随机风景');
  },
  
  // 测试图片加载失败函数（用于调试重试机制）
  testImageLoadError: function() {
    // 设置一个可能在小程序中404但浏览器可访问的测试链接
    // 这里使用一个占位符，用户可以根据实际情况修改为需要测试的URL
    this.setData({
      currentImage: 'https://img5.adesk.com/6647f35631f6136dd5cfdfe2?sign=83267563a56194a5e500347eb55bcfb8&t=6923284c',
      imageLoading: true
    });
    
    console.log('=== 开始测试图片加载失败重试机制 ===');
    console.log('测试URL:', this.data.currentImage);
    console.log('重试机制将自动在加载失败时触发，最多重试2次');
    
    // 模拟图片加载失败事件，测试重试逻辑
    this.imageLoadError({detail: {errMsg: '模拟的图片加载失败错误 - 测试重试机制'}});
  },
  
  // 图片加载成功事件
  imageLoadSuccess: function() {
    console.log('图片加载成功');
  },
  
  // 图片加载失败事件
  imageLoadError: function(e) {
    // 获取错误信息和当前图片链接
    const errorMsg = e.detail.errMsg || '未知错误';
    const imageUrl = this.data.currentImage;
    
    // 打印详细的错误信息和图片链接
    console.error('图片加载失败原因:', errorMsg);
    console.error('图片加载失败链接:', imageUrl);
    
    // 检查是否需要重试（最多重试2次）
    if (!this.imageRetryCount) {
      this.imageRetryCount = 0;
    }
    
    if (this.imageRetryCount < 2) {
      this.imageRetryCount++;
      console.log(`正在进行第${this.imageRetryCount}次重试...`);
      
      // 重新处理URL并尝试加载
      let retryUrl = imageUrl;
      
      // 重试前对URL进行更完善的处理
      // 1. 确保URL是完整的
      if (!retryUrl.startsWith('http://') && !retryUrl.startsWith('https://')) {
        retryUrl = 'https://' + retryUrl;
      }
      
      // 2. 尝试添加或修改User-Agent参数（如果URL包含查询参数）
      if (retryUrl.includes('?')) {
        // 添加一个随机参数避免缓存
        const randomParam = 't=' + Date.now();
        retryUrl = retryUrl + '&' + randomParam;
      } else {
        retryUrl = retryUrl + '?t=' + Date.now();
      }
      
      // 延迟后重试加载图片
      setTimeout(() => {
        console.log('使用新URL重试:', retryUrl);
        this.setData({
          currentImage: retryUrl,
          imageLoading: true
        });
      }, 1000 * this.imageRetryCount); // 每次重试间隔递增
    } else {
      // 重试次数用尽，显示失败
      this.imageRetryCount = 0; // 重置重试计数
      this.setData({
        imageLoading: false
      });
      wx.showToast({
        title: '图片加载失败，请重试',
        icon: 'none'
      });
    }
  },
  
  // 切换图片全屏显示
  toggleImageFullScreen: function() {
    this.setData({
      imageFullScreen: !this.data.imageFullScreen
    });
    
    // 进入全屏时，隐藏其他元素，退出时恢复
    if (this.data.imageFullScreen) {
      // 进入全屏，可以添加状态栏处理
      wx.setNavigationBarStyle({
        backgroundColor: '#000',
        frontColor: '#fff'
      });
    } else {
      // 退出全屏，恢复默认样式
      wx.setNavigationBarStyle({
        backgroundColor: '#fff',
        frontColor: '#000'
      });
    }
  },
  
  // 视频全屏状态变化事件
  onVideoFullScreenChange: function(e) {
    const { fullScreen, direction } = e.detail;
    this.videoFullScreen = fullScreen;
    
    if (fullScreen) {
      console.log('进入全屏，限制为竖屏模式');
      // 限制全屏为竖屏模式
      // 设置屏幕方向为竖屏
      wx.setScreenOrientation({
        orientation: 'portrait',
        success: function() {
          console.log('成功设置屏幕方向为竖屏');
        },
        fail: function(err) {
          console.error('设置屏幕方向失败:', err);
        }
      });
    } else {
      console.log('退出全屏');
      // 恢复屏幕方向为自动
      wx.setScreenOrientation({
        orientation: 'portrait-primary',
        success: function() {
          console.log('成功恢复屏幕方向');
        },
        fail: function(err) {
          console.error('恢复屏幕方向失败:', err);
        }
      });
    }
  },
  
  // 图片触摸开始事件
  onImageTouchStart: function(e) {
    this.imageTouchStartX = e.touches[0].clientX;
    this.imageTouchStartY = e.touches[0].clientY;
  },
  
  // 图片触摸移动事件
  onImageTouchMove: function(e) {
    // 可以在这里添加移动时的处理，如显示滑动指示器等
  },
  
  // 图片触摸结束事件
  onImageTouchEnd: function(e) {
    // 只有在全屏状态下才处理滑动切换
    if (!this.data.imageFullScreen) return;
    
    // 防抖动：如果正在处理上一次滑动，则不处理本次滑动
    if (this.isImageSliding) return;
    
    const endX = e.changedTouches[0].clientX;
    const endY = e.changedTouches[0].clientY;
    
    // 计算滑动距离
    const diffX = endX - this.imageTouchStartX;
    const diffY = endY - this.imageTouchStartY;
    
    // 判断是否为有效滑动（水平滑动且距离大于阈值）
    const slideThreshold = 30; // 调整滑动阈值，使滑动更灵敏
    if (Math.abs(diffX) > Math.abs(diffY) && Math.abs(diffX) > slideThreshold) {
      // 设置防抖动标志
      this.isImageSliding = true;
      
      if (diffX > 0) {
        // 向右滑动 - 获取上一个类型的图片
        this.getPreviousImageType();
      } else {
        // 向左滑动 - 获取下一个类型的图片
        this.getNextImageType();
      }
      
      // 延迟后重置防抖动标志
      setTimeout(() => {
        this.isImageSliding = false;
      }, 500);
    }
  },
  
  // 图片类型数组，用于循环切换
  imageTypes: ['随机女神', '随机动漫', '随机帅哥', '随机风景'],
  
  // 获取下一个图片类型
  getNextImageType: function() {
    // 找到当前类型的索引
    const currentType = this.currentImageType || this.imageTypes[0];
    const currentIndex = this.imageTypes.indexOf(currentType);
    // 计算下一个索引，循环切换
    const nextIndex = (currentIndex + 1) % this.imageTypes.length;
    const nextType = this.imageTypes[nextIndex];
    
    // 更新当前类型并获取图片
    this.currentImageType = nextType;
    this.getRandomImage(nextType);
    
    // 显示提示
    wx.showToast({
      title: nextType,
      icon: 'none',
      duration: 1000
    });
  },
  
  // 获取上一个图片类型
  getPreviousImageType: function() {
    // 找到当前类型的索引
    const currentType = this.currentImageType || this.imageTypes[0];
    const currentIndex = this.imageTypes.indexOf(currentType);
    // 计算上一个索引，循环切换
    const prevIndex = (currentIndex - 1 + this.imageTypes.length) % this.imageTypes.length;
    const prevType = this.imageTypes[prevIndex];
    
    // 更新当前类型并获取图片
    this.currentImageType = prevType;
    this.getRandomImage(prevType);
    
    // 显示提示
    wx.showToast({
      title: prevType,
      icon: 'none',
      duration: 1000
    });
  },
  
  // 获取随机视频的API调用函数
  getRandomVideo: function() {
    this.setData({
      videoLoading: true
    });
    
    wx.request({
      url: 'https://s3u416zkby.ny.takin.cc/freeapilocal/video',
      method: 'GET',
      success: (res) => {
        if (res.data.code === 200 && res.data.data && res.data.data.content) {
          // 提取并清理视频链接（去除可能的额外字符，如反引号）
          let videoUrl = res.data.data.content.trim();
          if (videoUrl.startsWith('`') && videoUrl.endsWith('`')) {
            videoUrl = videoUrl.substring(1, videoUrl.length - 1);
          }
          
          // 检查并转换协议：http -> https
          if (videoUrl.startsWith('http://')) {
            videoUrl = videoUrl.replace('http://', 'https://');
          }
          
          this.setData({
            currentVideo: videoUrl
          });
          
          // 自动播放视频（需要用户交互后才能播放）
          this.autoPlayVideo();
        } else {
          wx.showToast({
            title: '获取视频失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('视频API调用失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        this.setData({
          videoLoading: false
        });
      }
    });
  },
  
  // 自动播放视频
  autoPlayVideo: function() {
    const videoContext = wx.createVideoContext('dynamicVideo', this);
    if (videoContext) {
      videoContext.play().catch(err => {
        console.log('视频自动播放可能需要用户交互:', err);
      });
    }
  },
  
  // 视频触摸开始事件
  onVideoTouchStart: function(e) {
    // 记录触摸起始位置，仅用于全屏切换功能
    this.videoTouchStartX = e.touches[0].clientX;
    this.videoTouchStartY = e.touches[0].clientY;
  },
  
  // 视频触摸移动事件
  onVideoTouchMove: function(e) {
    // 不做任何处理，避免影响音量调节
    // 关闭滑动调节音量功能，阻止默认行为
  },
  
  // 视频触摸结束事件
  onVideoTouchEnd: function(e) {
    // 检查是否处于全屏状态
    const isFullScreen = this.videoFullScreen || false;
    
    if (!isFullScreen) return;
    
    // 防抖动：如果正在处理上一次滑动，则不处理本次滑动
    if (this.isVideoSliding) return;
    
    const endX = e.changedTouches[0].clientX;
    const endY = e.changedTouches[0].clientY;
    
    // 计算滑动距离
    const diffX = endX - this.videoTouchStartX;
    const diffY = endY - this.videoTouchStartY;
    
    // 判断是否为有效滑动（垂直滑动且距离大于阈值）
    const slideThreshold = 40;
    if (Math.abs(diffY) > Math.abs(diffX) && Math.abs(diffY) > slideThreshold) {
      // 设置防抖动标志
      this.isVideoSliding = true;
      
      // 无论向上还是向下滑动，都获取新视频
      this.getRandomVideo();
      
      // 显示提示
      wx.showToast({
        title: '切换视频',
        icon: 'none',
        duration: 1000
      });
      
      // 延迟后重置防抖动标志
      setTimeout(() => {
        this.isVideoSliding = false;
      }, 1000);
    }
  },
  
  // 随机视频按钮点击事件
  randomVideo: function() {
    this.getRandomVideo();
  },
  
  // 视频加载成功事件
  videoLoadSuccess: function() {
    console.log('视频加载成功');
  },
  
  // 视频加载失败事件
  videoLoadError: function() {
    console.error('视频加载失败');
    this.setData({
      videoLoading: false
    });
    wx.showToast({
      title: '视频加载失败',
      icon: 'none'
    });
  },
  
  // 通用的API调用函数
  callApi: function(type) {
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
    });
    
    // 调用API
    wx.request({
      url: `https://s3u416zkby.ny.takin.cc/freeapilocal/text?type=${encodeURIComponent(type)}`,
      method: 'GET',
      success: (res) => {
        if (res.data.code === 200 && res.data.data) {
          let displayContent = '';
          
          // 处理不同类型的返回格式
          if (type === '脑筋急转弯' && res.data.data.question && res.data.data.answer) {
            // 脑筋急转弯格式：问题+答案
            displayContent = `问题：${res.data.data.question}\n\n答案：${res.data.data.answer}`;
          } else if (res.data.data.content) {
            // 其他类型：直接显示content
            displayContent = res.data.data.content;
          } else {
            // 如果没有预期字段，尝试转换整个data对象
            displayContent = JSON.stringify(res.data.data, null, 2);
          }
          
          // 更新数据
          this.setData({
            dynamicContent: displayContent,
            originalContent: false
          });
        } else {
          wx.showToast({
            title: '获取内容失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('API调用失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        // 隐藏加载提示
        wx.hideLoading();
      }
    });
  },
  
  // 开心一笑按钮点击事件
  happyLaugh: function() {
    this.callApi('开心一笑');
  },
  
  // 奇葩对话按钮点击事件
  weirdDialogue: function() {
    this.callApi('奇葩对话');
  },
  
  // 脑筋急转弯按钮点击事件
  brainTeaser: function() {
    this.callApi('脑筋急转弯');
  }
});